Nous allons se pencher cette fois ci sur la possibilité d’intégration de prises télécommandées que nous pouvons trouver un peu par tout. Elles sont vendues avec leurs télécommande et utilisent le protocole 433 Mhz que nous voulons exploiter. Quelques exemples sur les photos:
 |  |
Attention a bien choisir les prises a protocole 433 MHz
Interception des codes envoi/réception de chaque prise.
La librairie 433Utils installé dans la Partie 2 nous permettra de déterminer les codes de chaque prise. Pour cela il sufit de vous conecter a votre Box DIY (notre RPi configuré dans la Partie 1) en SSH avec Putty par exemple.
saisissez le code suivant:
1 2 | cd ~/433Utils/RPi_utils sudo ./RFSniffer |
cd ~/433Utils/RPi_utils sudo ./RFSniffer
il vous reste maintenant a diriger votre télécommande vers votre Raspberry et appuyez sur les boutons.
Et la par magie votre code apparaît.
Copier le précieusement en précisant le numéro de chaque bouton.
Il ne reste plus qu’a utiliser ces codes avec notre RPi pour pouvoir commander nos prises. Pour cela nous allons coder un peu en C++ et PHP.
Pour envoyer le code vers une prise nous allons également utiliser la bibliothèque RCSwitch
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | /* * Usage: ./send <numéro prise><command> * Command is 0 for OFF and 1 for ON * 1 on - 327662 01001111111111101110 1 off - 327679 01001111111111111111 2 on - 01001111111101101100 2 off - 01001111111101111101 3 on - 01001111111110101111 3 off - 01001111111110111110 * * */ #include "RCSwitch.h" #include <stdlib.h> #include <stdio.h> int main(int argc, char *argv[]) { /* * output PIN is hardcoded for testing purposes * see https://projects.drogon.net/raspberry-pi/wiringpi/pins/ * for pin mapping of the raspberry pi GPIO connector */ int i = 0; int PIN = 0; int command = atoi(argv[1]); if (wiringPiSetup () == -1) return 1; RCSwitch mySwitch = RCSwitch(); mySwitch.setProtocol(3); mySwitch.enableTransmit(PIN); switch(command) { case 11: // 1 a ON for (i=1; i<10; i++) { mySwitch.send("01001111111111101110"); delayMicroseconds(810); } break; case 10: // 1 a Off for (i=1; i<10; i++) { mySwitch.send("01001111111111111111"); delayMicroseconds(810); } break; case 21: // 2 a On for (i=1; i<10; i++) { mySwitch.send("01001111111101101100"); delayMicroseconds(810); } break; case 20: // 2 a Off for (i=1; i<10; i++) { mySwitch.send("01001111111101111101"); delayMicroseconds(810); } break; case 31: // 3 a ON for (i=1; i<10; i++) { mySwitch.send("01001111111110101111"); delayMicroseconds(810); } break; case 30: // 3 a Off for (i=1; i<10; i++) { mySwitch.send("01001111111110111110"); delayMicroseconds(810); } break; default: printf("./send Numéro Prise+1=On ou 0=Off"); return -1; } return 0; } |
/*
* Usage: ./send <numéro prise><command>
* Command is 0 for OFF and 1 for ON
*
1 on - 327662
01001111111111101110
1 off - 327679
01001111111111111111
2 on -
01001111111101101100
2 off -
01001111111101111101
3 on -
01001111111110101111
3 off -
01001111111110111110
*
*
*/
#include "RCSwitch.h"
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
/*
* output PIN is hardcoded for testing purposes
* see https://projects.drogon.net/raspberry-pi/wiringpi/pins/
* for pin mapping of the raspberry pi GPIO connector
*/
int i = 0;
int PIN = 0;
int command = atoi(argv[1]);
if (wiringPiSetup () == -1) return 1;
RCSwitch mySwitch = RCSwitch();
mySwitch.setProtocol(3);
mySwitch.enableTransmit(PIN);
switch(command) {
case 11: // 1 a ON
for (i=1; i<10; i++) {
mySwitch.send("01001111111111101110");
delayMicroseconds(810);
}
break;
case 10: // 1 a Off
for (i=1; i<10; i++) {
mySwitch.send("01001111111111111111");
delayMicroseconds(810);
}
break;
case 21: // 2 a On
for (i=1; i<10; i++) {
mySwitch.send("01001111111101101100");
delayMicroseconds(810);
}
break;
case 20: // 2 a Off
for (i=1; i<10; i++) {
mySwitch.send("01001111111101111101");
delayMicroseconds(810);
}
break;
case 31: // 3 a ON
for (i=1; i<10; i++) {
mySwitch.send("01001111111110101111");
delayMicroseconds(810);
}
break;
case 30: // 3 a Off
for (i=1; i<10; i++) {
mySwitch.send("01001111111110111110");
delayMicroseconds(810);
}
break;
default:
printf("./send Numéro Prise+1=On ou 0=Off");
return -1;
}
return 0;
}
Il suffit de compiler le code puis le tester. (Attention le code change selon les prises).
L’usage est simple:
./send <numéro prise><commande>
Commande: 0 pour OFF et 1 pour ON
Exemple de commandes:
Allumer la prise 1
./send 11
Éteindre la prise 1
./send 10
Allumer la prise 2
./send 21
Éteindre la prise 3
./send 30
Nous pouvons facilement commander l’allumage et extinction des nos prises en ligne de commandes mais nous voudrions aussi de les inclurent dans Domoticz. Pour cela nous allons utiliser le périphérique virtuel “Dummy”, mais avant il faut pouvoir lancer notre code via une page web. Alors au boulot, nous allons écrire quelques lignes en PHP pour pouvoir exécuter notre send.cpp via une page web.
1 2 3 4 5 6 7 8 9 10 11 12 | <?php // API actioner les prises // ./send <numero Prise><on/off> // on = 1 // off = 0 // exemple ./send 10 $prise = $_GET['prise']; $etat = $_GET['etat']; system('sudo ./send '.$prise.$etat, $retval); print_r ($retval) ; ?> |
<?php
// API actioner les prises
// ./send <numero Prise><on/off>
// on = 1
// off = 0
// exemple ./send 10
$prise = $_GET['prise'];
$etat = $_GET['etat'];
system('sudo ./send '.$prise.$etat, $retval);
print_r ($retval) ;
?>le principe et le même que notre code send.cpp pour l’utiliser il suffit d’appeler la page send.php avec une variable prise et une etat sous la forme:
send.php?prise=1&etat=1
L’intégration dans Domoticz.
– Configuration
– Matériel
– Sélectionner Dummy et donner un nom par exemple Prise_1
– Cliquer sur “Capteur virtuel”
– Sélectionner Interrupteur
– OK
– Dans Interrupteur / ajout manuel
– Sélectionner la Prise_1 de Type X10
– Cliquer sur éditer
– remplir Action On et Off comme suit
– Votre prise et prêt a emploi
– recommencer pareil avec les autres prises
Bonjour,
superbe article en 3 parties.
C’est a un detail pres, exactement ce dont j’avais besoin.
Le detail ? Et bien j’utilise un rfxcom sur un PC avec Domoticz. Savez-vous si les outils 433utils existent dans une version compatible rfxcom ?
Ou si il y a une astuce pour remplacer le code vers le wiringpi par un code pour interroger le rfxcom ?
Merci d’avance pour vos reponses, et encore bravo pour l’article
Benoit
Bonjour Benoit et bien venu sur le site,
Je ne comprend pas très bien ta question:
“Savez-vous si les outils 433utils existent dans une version compatible rfxcom ”
RFXCom est directement compatible avec Domoticz.
Vous voulez faire quoi exactement ?
Bonjour,
excusez-moi je me suis peut-etre mal exprimé.
En effet, Domoticz et RFXCom fonctionnent tres bien ensemble.
Par contre, j’ai achete il y a qq temps un pack telecommande et 3 prises (ressemblant fortement a la photo de droite), qui, bien qu’etant sur la fréquence 433Mhz, n’est pas detecté par le RFXCom.
D’après mes recherches, la télécommande utilise le protocol DASH7, non reconnu par le firmware du RFXCom (à ce jour)
A la lecture de votre article, je pensais avoir trouvé la solution, par l’intermediaire des programmes de 433utils, pour piloter ces prises par l’intermediaire de Domoticz. (j’aurais recupere le signal, mis dans un script qui aurait ete execute lors d’une action dans Domoticz).
Comme à priori, les programmes 433utils se basent sur WiringPi, je ne peux l’exploiter. (mon Domoticz tourne sur un PC Debian avec RFXCom)
D’ou le sens de ma question, si vous connaissiez un equivalent qui me permettait de recevoir les messages et surtout d’envoyer par script ces commandes.
Cordialement,
Benoit.
Bonjour Benoit,
Oui je comprend mieux maintenant.
Par contre si tu es sur que tes prises ne sont pas compatibles avec RFXCom alors il te faut trouver un autre émetteur compatible,
ce n’est pas en changeant les bibliothèques ou le soft que cela deviendra compatible.
Merci pour toutes tes reponses.
Benoit.
Bonjour,
super tutoriel, j’ai commencé à faire ma propre box domotic il y a deux jours, mes plans utilise un PI2 et des module Aurel !
Le code du send.cpp diffère de mon coté j’ai un unitcode et un sytemcode a rentrer puis la commande 0 ou 1 pour le on / off.
A mon sens il faudrait ajouter les test de fonctionnement, le sniffer est simpa pour savoir si tout est ok, pour vérifier l’émission j’ai ouvert 2 putty (je suis en SSH sur mon PI2) l’un avec le sniffer, l’autre avec des sudo ./codesend 12345.
Je pense utiliser un php appelant la commande codesend plutot que le send, cela m’évitera de devoir recompiler le send.cpp a chaque fois que j’ajouterais un périphérique sur domoticz.
Je suis à l’affut de tes prochains tuto ! 🙂
Bonjour,
peux-tu nous indiquer comment vous faites pour executer le sudo depuis le client php, j’imagine que vous avez desactivé le requieretty du sudoers pour le user www-data ? Ou une autre technique ? J’ai quelques dificulter a faire éxécuter mes commande par mon script PHP 🙁
Bonjour,
Oui j’ai modifié sudoers, pour exécuter JUSTE le script send.cpp en sudo
regardez le tuto ici
http://blogmotion.fr/systeme/executer-un-script-shell-avec-permission-root-en-php-1312
Super merci beaucoup, je tente le coup ce soir.
bonjour
je suis nouveaux dans la domotique j ai récupéré les codes que je dois faire
Bonjour zrom69,
il suffit de lire la suite c’est expliqué 😉
super tuto ça m’évite d’investir dans un RFXcom.
Ce code fonctionne-il avec des prises Chacon ?
Bonjour zazalex.
Naturelement ça fonctionne sur les prise Chacon.
Bonjour à tous,
nouveau venu sur le site et sur la domotique sur framboise en général, je m’essaye progressivement à différents montage.
Je cherche notamment, comme beaucoup à piloter les fameuses prises 433 Mhz (les miennes ressemblent comme 2 gouttes d’eau à celles de la photo de droite en haut de la page).
j’ai fait les montages proposés.
a priori ils sont bons par si je fais un RFsniffer, j’obtiens bien un code à 7 digits de la part de chaque bouton de la télécommande.
Si j’ouvres 2 fenêtres putty, une avec Rfsniffer; une avec codesend, le code que j’envoi est bien “sniffé”.
par contre pas moyen de faire commuter la moindre prise avec le raspberry.
j’arrive à faire fonctionner codesend mais uniquement en boucle entre l’émetetteur et le récepteur; pas moyen de faire commuter la prise (pas de messages d’erreur reçu)
par contre dès que j’essaie ./send, quelques soient les combinaisons, j’obtiens systématiquement une “erreur de segmentation”; j’ai essayé plusieurs combinaisons, (0 ,1 , on off…) et toujours le même résultats.
quelqu’un a-t-il une idée pour me faire progresser ?
merci; Denis
Bonjour
Pouvez vous publier le code source de votre “codesend”
Pour “send” attention au code des prise il est en binaire et non hexa
mySwitch.send(“01001111111111101110”);
Bonjour,
désolé pour ce retour tardif.
j’ai le consend.cpp suivant :
‘codesend’ hacked from ‘send’ by @justy
– The provided rc_switch ‘send’ command uses the form systemCode, unitCode, command
which is not suitable for our purposes. Instead, we call
send(code, length); // where length is always 24 and code is simply the code
we find using the RF_sniffer.ino Arduino sketch.
Usage: ./codesend decimalcode
(Use RF_Sniffer.ino to check that RF signals are being produced by the RPi’s transmitter)
*/
#include “RCSwitch.h”
#include
#include
int main(int argc, char *argv[]) {
// This pin is not the first pin on the RPi GPIO header!
// Consult https://projects.drogon.net/raspberry-pi/wiringpi/pins/
// for more information.
int PIN = 0;
// Parse the firt parameter to this command as an integer
int code = atoi(argv[1]);
if (wiringPiSetup () == -1) return 1;
printf(“sending code[%i]\n”, code);
RCSwitch mySwitch = RCSwitch();
mySwitch.enableTransmit(PIN);
mySwitch.send(code, 24);
return 0;
}
et le send.cpp suivant :
/*
Usage: ./send
Command is 0 for OFF and 1 for ON
*/
#include “RCSwitch.h”
#include
#include
int main(int argc, char *argv[]) {
/*
output PIN is hardcoded for testing purposes
see https://projects.drogon.net/raspberry-pi/wiringpi/pins/
for pin mapping of the raspberry pi GPIO connector
*/
int PIN = 0;
char* systemCode = argv[1];
int unitCode = atoi(argv[2]);
int command = atoi(argv[3]);
if (wiringPiSetup () == -1) return 1;
printf(“sending systemCode[%s] unitCode[%i] command[%i]\n”, systemCode, unitCode, command);
RCSwitch mySwitch = RCSwitch();
mySwitch.enableTransmit(PIN);
switch(command) {
case 1:
mySwitch.switchOn(systemCode, unitCode);
break;
case 0:
mySwitch.switchOff(systemCode, unitCode);
break;
default:
printf(“command[%i] is unsupported\n”, command);
return -1;
}
return 0;
}
toujours aucun résultats probants.
Pour ce qui est du code présenté plus haut, j’ai systématiquement des erreurs lors de la compilation ;
:45:49: warning: deprecated conversion from string constant to ‘char*’ en ligne 45, 57, 63…
et : référence indéfinie vers « RCSwitch::RCSwitch() » …
j’ai essayé d’autres codes, mais rien de plus pour le moment.
je n’ai pas testé d’envoi direct de code binaire, je ne sais pas comment il faut le coder.
merci d’avance
Denis
Bonjour Denis,
Pour commencer tu as 2 include(s) qui ne sert a rien.
a mon avis il faut les remplacer par:
#include
#include
Apres c’est une histoire de base, peut tu publier la commende que tu exécutes et qui provoque l’erreur.
Le code que tu récupères et en base 10.
Merci
Salut,
Le week-end a été riche en tests en tout genre, et enfin j’ai réussi à piloter une série de prises!! j’ai même avec un simple bout de fil de 17cm en guise d’antenne une super distance d’emission (maison 150 m2 sur 2 étages, et ça passe partout, y compris à travers la dalle de béton !!!).
Je vais pouvoir continuer le développement, et notamment l’intégration dans Domoticz, mais je ne suis pas inquiet sur cette partie.
Par contre sur 4 types de prises, un seul fonctionne. As-tu une idée qui permettrait d’avancer sur ce terrain pour décoder le protocole des autres, qui doit quand même être proche les unes des autres.
Pour info, elles viennent toutes de la grande distribution.
celles qui fonctionnent sont marquées :
pas de marque; Ref 6899; importées par COMI; elles sont à dip-switches (5 pour la télécommande; 5 pour la prise); achetées il y a près de 10 ans à Intermarché.
les autres : (les dernières achetées) : FHT7901 433.0(-434.79 Mhz Zhejiang Fuhaota Electric and tools PI 15137 avec également 10 Dip-switches ; pas comptaticle avec les précédentes, et dont je n’arrive même pas à sniffer le code emis par la télécommande.
mais aussi Silvercrest IAN7423 type 10164 D (Lidl) sans switches (je n’ai plus la télécommande)
et TechX ref 941, modèle BHC9938F (sans switches); j’en ai plusieurs qui fonctionnent avec la télécommande, mais je n’arrive pas à les commander avec la framboise.
NB: j’arrive uniquement à commander les prises avec ./send que je t’ai envoyé dans le post précédent en utilisant la syntaxe : ./send code_binaire_a_5_bits_de_la_telecommande code_à_1_digit_de_la_prise_à_commuter (1 à 5 selon position des dipswitches) et 0 ou 1 pour éteindre / allumer
Pas réussi à utiliser ./codesend.
Merci par avance de ton aide.
Bonjour Denis,
Content pour ta réussite,
Pour les prise restante essai d’analyser le signale avec un oscilloscope, souvent certain producteur crypte le signale, le binaire inversé, précédé d’un 1 ou un 0 etc…..
salut et merci pour ce retour,
je ne suis pas équipé en oscilloscope.
par contre, aurais-tu sous le coude un tout petit script, simplifié à l’extrême, qui lirait de manière ultra simplifiée le port GPIO en entrée, relié au récepteur 433 Mhz, par exemple de manière synchrone (à une fréquence cohérente avec la porteuse je suppose) pour soit l’afficher soit le poser dans un fichier log.txt. peut-être ainsi en observant la différence de comportement entre le bruit de fond et une trame émise par une télécommande je pourrais peut-être avancer : bref un “RFSniffer” ultra simplifié, directement en binaire.
Salut,
Si le signale est vraiment crypté, alors il y a qu’un oscilloscope qui te permettra de le déterminer.
Salut,
j’essaye tant bien que mal de faire fonctionner mes prises phenix yc-4000s.
j’ai sniffé le code de la telecommande pour chaques prises avec rfsniffer, puis je l’ai converti en binaire et mis dans le send.cpp.
je precise que je ne connais absolument pas la programmation (je compte bientôt y remedier ^^)
Je dispose d’un RPi 1ére generation. avec un autre tuto ca fonctionne parfaitement: https://arno0x0x.wordpress.com/2015/04/02/rf433-outlet/
mais je prefere le tiens car je veux les integrer dans domoticz.
lorsque je fait sudo ./send 11 rien ne se passe :/ et le sniffer ne detecte rien, de plus lors de la compilation j’ai ça:
send.cpp: In function ‘int main(int, char**)’:
send.cpp:49:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000100010101010001”);
^
send.cpp:55:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000100010101010100”);
^
send.cpp:61:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101000101010001”);
^
send.cpp:67:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101000101010100”);
^
send.cpp:73:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101010001010001”);
^
send.cpp:79:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101010001010100”);
^
send.cpp:85:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101010100010001”);
^
send.cpp:91:50: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
mySwitch.send(“100000101010100010100”);
^
g++ RCSwitch.o send.o -o send -lwiringPi
g++ -c -o codesend.o codesend.cpp
g++ RCSwitch.o codesend.o -o codesend -lwiringPi
g++ -c -o RFSniffer.o RFSniffer.cpp
g++ RCSwitch.o RFSniffer.o -o RFSniffer -lwiringPi
Super tuto merci !!
Moi j’en suis à essayer de récupérer le code de mes prises achetées chez Electro Dépôt (http://www.electrodepot.fr/prise-rf–prises-telecommandees-x-3-interieure.html) .
En effet, le codesend est bien “snifé” et je recois bien le code tapé.
Cependant lorsque j’utilise la télécommande rien ne se passe. L’emetteur de la télécommande est estampillé 433.92 Mhz et j’ai acheté émetteur/récepteur 433 Mhz (https://www.amazon.fr/gp/product/B00V4ISS38/ref=oh_aui_detailpage_o08_s00?ie=UTF8&psc=1).
L’émetteur/récepteur en ma possession fonctionne t’il sur toute la bande 433 Mhz (y compris 433.92) ? Pensez vous que les télécommandes soient cryptées ? Avec quoi d’autre puis je faire un autre test ?
Merci de votre retour.
Bonsoir marsho94,
si pas de résultat alors tu as 99.9% de chance que le code est “crypté” pour ça il faut analyser le code avec un oscilloscope.
Merci pour ce retour plus que rapide !
Auriez vous un lien ou des modèles de prises compatibles ?
Bonjour et merci pour vôtre tuto,
voilà je cherche à récupérer l’ID de communication de mes volet.
j’ai pour celà un raspberry et un module rfxcom , pourriez vous me dire si celà est compatible avec les partie 2 et 3 de votre tuto ?
merci par avance.
Bonsoir
Quel type de volets ?
Si vs avez un rfxcom récent il est plus facile d’utiliser le RFXManager.
la marque dess volet est compatible avec les le rfxcom.
Cependant même avec RFXManager, j’ai besoin de connaitre l'”ID” de communication pour chaque volet ….
A vs de choisir un ID unique.
Cependant j’ai aucun bouton d’apprentissage ni sur le volet ni sur la télécommande … merci quand même …
Un des bouton ou associations de plusieurs doivent probablement remplacer le mode apprentissage.
Bonjour,
Merci pour votre tuto ! J’ai réussi la quasi totalité des étapes mais je bloque au moment de créer le fichier PHP. Suffit il de créer un fichier avec la commande nano, de le nommer send.php et de copier le code que vous donner ? Je l’ai mis dans le répertoire /domoticz/scripts/php, est ce correct ?
Une fois dans domoticz, l’adresse ip est elle celle du raspberry où est installé domoticz ?
Si l’IP de mon rasp est 192.168.1.42, est ce que la synthaxe : http://192.168.1.42/domoticz/scripts/php/code.php?prise=1&etat=1 est bonne ?
Merci et à bientôt !
Bonjour,
Avez-vous résolu votre problème ?
Je suis bloqué comme vous.
Merci d’avance pour votre aide
[…] l’utilisation de protocole 433 MHz avec les prises télécommandées (voir mon article Domotique DIY – Partie 3 – Hack des prises télécommandées) nous allons agrandir notre système #DIY avec les interrupteurs / Switch […]